package com.ruoyi.business.modbus.service.digitalpetri;

import java.util.List;
import java.util.ArrayList;
public class ByteArrayConverter {

    /**

     将字节数组按 2 个字节一组转换为无符号整数列表（大端模式：高位在前）
     @param bytes 输入字节数组
     @return 无符号整数列表（每个元素对应一组 2 字节）
     */
    public static List<Integer> bytesToUnsignedInts(byte[] bytes) {
        List<Integer> result = new ArrayList<>();
        if (bytes == null || bytes.length == 0) {
            return result;
        }
        // 按 2 个字节一组遍历
        for (int i = 0; i < bytes.length; i += 2) {
            // 若剩余字节不足 2 个，仅处理当前字节（高位补 0）
            if (i + 1 >= bytes.length) {
                byte highByte = bytes [i];
                int value = (highByte & 0xFF) << 8; // 低 8 位补 0
                result.add (value);
            } else {
                byte highByte = bytes [i];
                byte lowByte = bytes [i + 1];
                // 组合为无符号整数
                int value = ((highByte & 0xFF) << 8) | (lowByte & 0xFF);
                result.add (value);
            }
        }
        return result;
    }
    
    /**
     * 将字节数组转换为布尔值列表（每个字节对应8个布尔值）
     * @param bytes 输入字节数组
     * @param quantity 期望的布尔值数量
     * @return 布尔值列表
     */
    public static List<Boolean> bytesToBooleans(byte[] bytes, int quantity) {
        List<Boolean> result = new ArrayList<>();
        if (bytes == null || bytes.length == 0) {
            return result;
        }
        
        int bitCount = 0;
        for (byte b : bytes) {
            for (int i = 7; i >= 0 && bitCount < quantity; i--) {
                result.add(((b >> i) & 0x01) == 1);
                bitCount++;
            }
        }
        
        return result;
    }
    
    /**
     * 将布尔值列表转换为字节数组（每个字节对应8个布尔值）
     * @param booleans 输入布尔值列表
     * @return 字节数组
     */
    public static byte[] booleansToBytes(List<Boolean> booleans) {
        if (booleans == null || booleans.isEmpty()) {
            return new byte[0];
        }
        
        int byteCount = (booleans.size() + 7) / 8; // 向上取整
        byte[] result = new byte[byteCount];
        
        for (int i = 0; i < booleans.size(); i++) {
            if (booleans.get(i)) {
                int byteIndex = i / 8;
                int bitIndex = 7 - (i % 8); // 大端模式，高位在前
                result[byteIndex] |= (1 << bitIndex);
            }
        }
        
        return result;
    }
    
    /**
     * 将整数列表转换为字节数组（每个整数对应2个字节，大端模式）
     * @param ints 输入整数列表
     * @return 字节数组
     */
    public static byte[] intsToBytes(List<Integer> ints) {
        if (ints == null || ints.isEmpty()) {
            return new byte[0];
        }
        
        byte[] result = new byte[ints.size() * 2];
        int byteIndex = 0;
        
        for (Integer value : ints) {
            if (value != null) {
                // 大端模式：高位在前
                result[byteIndex++] = (byte) ((value >> 8) & 0xFF);
                result[byteIndex++] = (byte) (value & 0xFF);
            }
        }
        
        return result;
    }
}
